home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / term / term41source.lha / Extras / Source / term-Source.lha / termAmigaGuide.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-17  |  8.4 KB  |  416 lines
  1. /*
  2. **    termAmigaGuide.c
  3. **
  4. **    AmigaGuide support routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Local data. */
  13.  
  14. STATIC STRPTR             ContextList[51];
  15. STATIC AMIGAGUIDECONTEXT     Context;
  16. STATIC struct NewAmigaGuide     NewGuide;
  17. STATIC struct Process        *GuideProcess;
  18. STATIC LONG             GuideContextID = CONTEXT_MAIN;
  19.  
  20.     /* GuideServer(VOID):
  21.      *
  22.      *    AmigaGuide server, handles all the signal processing.
  23.      */
  24.  
  25. STATIC VOID __saveds
  26. GuideServer(VOID)
  27. {
  28.         /* Open the help text file asynchronously... */
  29.     
  30.     if(Context = OpenAmigaGuideAsync(&NewGuide,TAG_DONE))
  31.     {
  32.         ULONG    GuideMask,
  33.             Signals;
  34.         BYTE    Done = FALSE;
  35.     
  36.             /* Pick up the signal notification mask. */
  37.     
  38.         GuideMask = AmigaGuideSignal(Context);
  39.     
  40.             /* Clear the context stack. */
  41.     
  42.         SetAmigaGuideContext(Context,0,TAG_DONE);
  43.     
  44.             /* Flag the main process to continue. */
  45.     
  46.         Signal(ThisProcess,SIG_HANDSHAKE);
  47.     
  48.             /* Go into input loop. */
  49.     
  50.         do
  51.         {
  52.                 /* Wait for a signal... */
  53.     
  54.             Signals = Wait(SIG_KILL | GuideMask);
  55.     
  56.                 /* Are we to quit? */
  57.     
  58.             if(Signals & SIG_KILL)
  59.                 Done = TRUE;
  60.     
  61.                 /* Process icoming AmigaGuide messages. */
  62.     
  63.             if(Signals & GuideMask)
  64.             {
  65.                 struct AmigaGuideMsg *GuideMessage;
  66.     
  67.                 while(GuideMessage = GetAmigaGuideMsg(Context))
  68.                     ReplyAmigaGuideMsg(GuideMessage);
  69.             }
  70.         }
  71.         while(!Done);
  72.     
  73.             /* Close the help text file. */
  74.     
  75.         CloseAmigaGuide(Context);
  76.     }
  77.  
  78.         /* Lock & quit. */
  79.  
  80.     Forbid();
  81.  
  82.     GuideProcess = NULL;
  83.  
  84.     Signal(ThisProcess,SIG_HANDSHAKE);
  85. }
  86.  
  87.     /* GuideLaunch(LONG ContextID):
  88.      *
  89.      *    Launch the AmigaGuide help file server.
  90.      */
  91.  
  92. STATIC BYTE
  93. GuideLaunch(LONG ContextID)
  94. {
  95.         /* Is the main program running and is this the
  96.          * main program to make the call?
  97.          */
  98.  
  99.     if(Window && SysBase -> ThisTask == ThisProcess)
  100.     {
  101.             /* Is the help file server already running? */
  102.  
  103.         if(!GuideProcess)
  104.         {
  105.             if(!AmigaGuideBase)
  106.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  107.  
  108.             if(AmigaGuideBase)
  109.             {
  110.                 BYTE IsValidFile = TRUE;
  111.  
  112.                     /* Do we have a valid AmigaGuide file name? */
  113.  
  114.                 if(Config -> PathConfig -> HelpFile[0])
  115.                 {
  116.                     if(!GetFileSize(Config -> PathConfig -> HelpFile))
  117.                         IsValidFile = FALSE;
  118.                 }
  119.                 else
  120.                     IsValidFile = FALSE;
  121.  
  122.                     /* Do we have a valid AmigaGuide file name? */
  123.  
  124.                 if(!IsValidFile)
  125.                 {
  126.                         /* Don't pop up the file requester if any
  127.                          * time-critical services are currently running!
  128.                          */
  129.  
  130.                     if(ContextID == CONTEXT_TRANSFER || ContextID == CONTEXT_DIAL)
  131.                     {
  132.                         DisplayBeep(Window -> WScreen);
  133.  
  134.                         return(FALSE);
  135.                     }
  136.                     else
  137.                     {
  138.                         struct FileRequester    *FileRequest;
  139.                         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  140.                                      DummyName[40];
  141.  
  142.                             /* Provide a default name if necessary. */
  143.  
  144.                         if(!Config -> PathConfig -> HelpFile[0])
  145.                             strcpy(Config -> PathConfig -> HelpFile,"PROGDIR:term.guide");
  146.  
  147.                             /* Block the windows. */
  148.  
  149.                         BlockWindows();
  150.  
  151.                             /* Get file and path name. */
  152.  
  153.                         strcpy(DummyBuffer,Config -> PathConfig -> HelpFile);
  154.  
  155.                         if(DummyBuffer[0])
  156.                         {
  157.                             STRPTR DummyChar;
  158.  
  159.                             if(FilePart(DummyBuffer) == DummyBuffer)
  160.                             {
  161.                                 strcpy(DummyName,DummyBuffer);
  162.  
  163.                                 DummyBuffer[0] = 0;
  164.                             }
  165.                             else
  166.                             {
  167.                                 strcpy(DummyName,FilePart(DummyBuffer));
  168.  
  169.                                 DummyChar = PathPart(DummyBuffer);
  170.  
  171.                                 *DummyChar = 0;
  172.                             }
  173.                         }
  174.                         else
  175.                             DummyName[0] = 0;
  176.  
  177.                             /* Get the help text file name. */
  178.  
  179.                         if(FileRequest = GetFile(Window,LocaleString(MSG_PATHPANEL_SELECT_HELP_FILE_TXT),DummyBuffer,DummyName,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  180.                         {
  181.                             if(GetFileSize(DummyBuffer))
  182.                             {
  183.                                 strcpy(Config -> PathConfig -> HelpFile,DummyBuffer);
  184.  
  185.                                 IsValidFile = TRUE;
  186.                             }
  187.  
  188.                             FreeAslRequest(FileRequest);
  189.                         }
  190.  
  191.                             /* Release the windows... */
  192.  
  193.                         ReleaseWindows();
  194.                     }
  195.                 }
  196.  
  197.                     /* Do we finally have a valid file name? */
  198.  
  199.                 if(IsValidFile)
  200.                 {
  201.                     STATIC LONG NodeTable[] =
  202.                     {
  203.                         MSG_TERMAMIGAGUIDE_NODE_00_TXT,
  204.                         MSG_TERMAMIGAGUIDE_NODE_01_TXT,
  205.                         MSG_TERMAMIGAGUIDE_NODE_02_TXT,
  206.                         MSG_TERMAMIGAGUIDE_NODE_03_TXT,
  207.                         MSG_TERMAMIGAGUIDE_NODE_04_TXT,
  208.                         MSG_TERMAMIGAGUIDE_NODE_05_TXT,
  209.                         MSG_TERMAMIGAGUIDE_NODE_06_TXT,
  210.                         MSG_TERMAMIGAGUIDE_NODE_07_TXT,
  211.                         MSG_TERMAMIGAGUIDE_NODE_08_TXT,
  212.                         MSG_TERMAMIGAGUIDE_NODE_09_TXT,
  213.                         MSG_TERMAMIGAGUIDE_NODE_10_TXT,
  214.                         MSG_TERMAMIGAGUIDE_NODE_11_TXT,
  215.                         MSG_TERMAMIGAGUIDE_NODE_12_TXT,
  216.                         MSG_TERMAMIGAGUIDE_NODE_13_TXT,
  217.                         MSG_TERMAMIGAGUIDE_NODE_14_TXT,
  218.                         MSG_TERMAMIGAGUIDE_NODE_15_TXT,
  219.                         MSG_TERMAMIGAGUIDE_NODE_16_TXT,
  220.                         MSG_TERMAMIGAGUIDE_NODE_17_TXT,
  221.                         MSG_TERMAMIGAGUIDE_NODE_18_TXT,
  222.                         MSG_TERMAMIGAGUIDE_NODE_19_TXT,
  223.                         MSG_TERMAMIGAGUIDE_NODE_20_TXT,
  224.                         MSG_TERMAMIGAGUIDE_NODE_21_TXT,
  225.                         MSG_TERMAMIGAGUIDE_NODE_22_TXT,
  226.                         MSG_TERMAMIGAGUIDE_NODE_23_TXT,
  227.                         MSG_TERMAMIGAGUIDE_NODE_24_TXT,
  228.                         MSG_TERMAMIGAGUIDE_NODE_25_TXT,
  229.                         MSG_TERMAMIGAGUIDE_NODE_26_TXT,
  230.                         MSG_TERMAMIGAGUIDE_NODE_27_TXT,
  231.                         MSG_TERMAMIGAGUIDE_NODE_28_TXT,
  232.                         MSG_TERMAMIGAGUIDE_NODE_29_TXT,
  233.                         MSG_TERMAMIGAGUIDE_NODE_30_TXT,
  234.                         MSG_TERMAMIGAGUIDE_NODE_31_TXT,
  235.                         MSG_TERMAMIGAGUIDE_NODE_32_TXT,
  236.                         MSG_TERMAMIGAGUIDE_NODE_33_TXT,
  237.                         MSG_TERMAMIGAGUIDE_NODE_34_TXT,
  238.                         MSG_TERMAMIGAGUIDE_NODE_35_TXT,
  239.                         MSG_TERMAMIGAGUIDE_NODE_36_TXT,
  240.                         MSG_TERMAMIGAGUIDE_NODE_37_TXT,
  241.                         MSG_TERMAMIGAGUIDE_NODE_38_TXT,
  242.                         MSG_TERMAMIGAGUIDE_NODE_39_TXT,
  243.                         MSG_TERMAMIGAGUIDE_NODE_40_TXT,
  244.                         MSG_TERMAMIGAGUIDE_NODE_41_TXT,
  245.                         MSG_TERMAMIGAGUIDE_NODE_42_TXT,
  246.                         MSG_TERMAMIGAGUIDE_NODE_43_TXT,
  247.                         MSG_TERMAMIGAGUIDE_NODE_44_TXT,
  248.                         MSG_TERMAMIGAGUIDE_NODE_45_TXT,
  249.                         MSG_TERMAMIGAGUIDE_NODE_46_TXT,
  250.                         MSG_TERMAMIGAGUIDE_NODE_47_TXT,
  251.                         MSG_TERMAMIGAGUIDE_NODE_48_TXT,
  252.                         MSG_TERMAMIGAGUIDE_NODE_49_TXT,
  253.  
  254.                         -1
  255.                     };
  256.  
  257.                         /* Provide the context node names (note: language
  258.                          * specific!).
  259.                          */
  260.  
  261.                     LocalizeStringTable(ContextList,NodeTable);
  262.  
  263.                         /* Clear the instance. */
  264.  
  265.                     memset(&NewGuide,0,sizeof(struct NewAmigaGuide));
  266.  
  267.                         /* Fill in the structure. */
  268.  
  269.                     NewGuide . nag_BaseName        = "termHelp";
  270.                     NewGuide . nag_Name        = Config -> PathConfig -> HelpFile;
  271.                     NewGuide . nag_ClientPort    = "TERM_HELP";
  272.                     NewGuide . nag_Context        = ContextList;
  273.                     NewGuide . nag_Screen        = Window -> WScreen;
  274.  
  275.                         /* Launch the server process and
  276.                          * wait for reply.
  277.                          */
  278.  
  279.                     Forbid();
  280.  
  281.                     if(GuideProcess = CreateNewProcTags(
  282.                         NP_Entry,    GuideServer,
  283.                         NP_Name,    "term AmigaGuide Process",
  284.                     TAG_DONE))
  285.                     {
  286.                         ClrSignal(SIG_HANDSHAKE);
  287.  
  288.                         Wait(SIG_HANDSHAKE);
  289.                     }
  290.  
  291.                     Permit();
  292.                 }
  293.             }
  294.         }
  295.  
  296.             /* Pop the main screen to the front if necessary. */
  297.  
  298.         if(GuideProcess)
  299.         {
  300.             ScreenToFront(Window -> WScreen);
  301.  
  302.             return(TRUE);
  303.         }
  304.         else
  305.         {
  306.             if(AmigaGuideBase)
  307.             {
  308.                 CloseLibrary(AmigaGuideBase);
  309.  
  310.                 AmigaGuideBase = NULL;
  311.             }
  312.  
  313.             DisplayBeep(Window -> WScreen);
  314.  
  315.             return(FALSE);
  316.         }
  317.     }
  318.     else
  319.     {
  320.         if(GuideProcess && Window)
  321.         {
  322.             ScreenToFront(Window -> WScreen);
  323.  
  324.             return(TRUE);
  325.         }
  326.         else
  327.             return(FALSE);
  328.     }
  329. }
  330.  
  331.     /* GuideCleanup():
  332.      *
  333.      *    Terminate the AmigaGuide server and free the
  334.      *    associated resources.
  335.      */
  336.  
  337. VOID
  338. GuideCleanup()
  339. {
  340.     if(GuideProcess)
  341.     {
  342.         Forbid();
  343.  
  344.         Signal(GuideProcess,SIG_KILL);
  345.  
  346.         ClrSignal(SIG_HANDSHAKE);
  347.  
  348.         Wait(SIG_HANDSHAKE);
  349.  
  350.         Permit();
  351.     }
  352.  
  353.     if(AmigaGuideBase)
  354.     {
  355.         CloseLibrary(AmigaGuideBase);
  356.  
  357.         AmigaGuideBase = NULL;
  358.     }
  359. }
  360.  
  361.     /* GuideContext(LONG NewContextID):
  362.      *
  363.      *    Set the global AmigaGuide context.
  364.      */
  365.  
  366. VOID __regargs
  367. GuideContext(LONG NewContextID)
  368. {
  369.     GuideContextID = NewContextID;
  370. }
  371.  
  372. ULONG __saveds __asm
  373. GuideSetupHook(register __a0 struct Hook *Hook,register __a1 struct IBox *Bounds,register __a2 HelpMsg *HelpMessage)
  374. {
  375.     if(GuideLaunch(GuideContextID))
  376.     {
  377.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  378.         SendAmigaGuideContext(Context,TAG_DONE);
  379.  
  380.         return(TRUE);
  381.     }
  382.     else
  383.         return(FALSE);
  384. }
  385.  
  386.     /* GuideSetup():
  387.      *
  388.      *    Try to display the currently selected AmigaGuide
  389.      *    help text.
  390.      */
  391.  
  392. VOID
  393. GuideSetup()
  394. {
  395.     if(GuideLaunch(GuideContextID))
  396.     {
  397.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  398.         SendAmigaGuideContext(Context,TAG_DONE);
  399.     }
  400. }
  401.  
  402.     /* GuideDisplay(LONG ContextID):
  403.      *
  404.      *    Try to display an AmigaGuide help text.
  405.      */
  406.  
  407. VOID __regargs
  408. GuideDisplay(LONG ContextID)
  409. {
  410.     if(GuideLaunch(ContextID))
  411.     {
  412.         SetAmigaGuideContext(Context,ContextID,TAG_DONE);
  413.         SendAmigaGuideContext(Context,TAG_DONE);
  414.     }
  415. }
  416.